{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1\n",
    "\n",
    "1. 语句\n",
    "\n",
    "- 1. [变量声明]\n",
    "  - 变量声明 (var const let)\n",
    "  - 类声明 (类声明，类表达式，抽象类)\n",
    "  - 函数声明 (函数声明 函数表达式)\n",
    "  - 生成器函数声明 (生成器函数声明 生成器函数表达式)\n",
    "  - async 函数声明\n",
    "  - async 生成器函数声明\n",
    "  - 装饰器语句\n",
    "  - using 声明\n",
    "  - 枚举声明 enum\n",
    "  - [类型]\n",
    "    - 类型别名声明 type\n",
    "    - 接口声明 interface\n",
    "\n",
    "- 2. [分支语句]\n",
    "  - if 语句\n",
    "  - else 语句\n",
    "  - switch 语句\n",
    "  - case 子句\n",
    "  - default 子句\n",
    "\n",
    "- 3. [循环语句]\n",
    "  - for 系列语句\n",
    "  - while 语句\n",
    "  - do...while 语句\n",
    "  - continue 声明\n",
    "  - break 语句\n",
    "  - label 语句\n",
    "\n",
    "- 4. [异常处理]\n",
    "  - try 语句\n",
    "  - catch 语句\n",
    "  - finally 语句\n",
    "  - throw 语句\n",
    "\n",
    "- 5. [返回]\n",
    "  - yield 表达式\n",
    "  - return 语句\n",
    "\n",
    "- 6. [esm]\n",
    "  - export 语句\n",
    "  - import 语句\n",
    "  - [类型定义模块]\n",
    "    - namespace 声明 (内部)\n",
    "    - module 声明 (外部)\n",
    "\n",
    "- 7. [其他]\n",
    "  - 表达式语句 (如 new )\n",
    "  - 块语句\n",
    "  - debugger 语句\n",
    "  - 空语句\n",
    "  - with 语句 (ts 中无法获得 正确的类型)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "## 2. 声明/绑定表达式\n",
    "   简单变量声明 - const断言(断言成最窄的基本)\n",
    "   解构变量声明 - 解构模式(模式匹配)\n",
    "\n",
    "- 声明初始化\n",
    "\n",
    "声明修饰符\n",
    "\n",
    "类型注解\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "## 3. 函数\n",
    "\n",
    "3.1 函数声明\n",
    "函数类型签名\n",
    "\n",
    "重载签名: 函数叠放\n",
    "\n",
    "实现签名: 最后一个重载签名\n",
    "\n",
    "调用签名: **类型签名**\n",
    "  - 对象上的匿名函数代表 调用签名\n",
    "  - ```ts\n",
    "    { ():void }\n",
    "    ```\n",
    "\n",
    "- 参数列表\n",
    "- 访问修饰符 (可选修饰符?)\n",
    "\n",
    "### 函数表达式\n",
    "\n",
    "箭头函数\n",
    "\n",
    "- 区别于 普通函数\n",
    "  - 无 this (使用环境的this)\n",
    "  - 无 ('arguments', 'caller')[[caller]], 'prototype': [[Prototype]]\n",
    "  - 无对应的 generator 的写法\n",
    "\n",
    "递归与循环\n",
    "\n",
    "- CPS\n",
    "- 尾递归优化([宿主仅safari/webkit支持](https://compat-table.github.io/compat-table/es6/))\n",
    "- 递归转循环 堆/队列\n",
    "\n",
    "> 函数表达式/函数语句 的 this 是运行时绑定(动态绑定)需要指定类型\n",
    ">\n",
    "> 箭头函数本身没有定义this (为undefined)\n",
    ">\n",
    "> 对象的成员方法/函数属性(函数语句/函数表达式)的this是定义时绑定(使用builtin类型this)\n",
    "\n",
    "构造函数\n",
    "  - 在参数前加类属性的 权限标识符可以视为直接在类中 创建该参数的同名属性\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. (对象)类型字面量\n",
    "\n",
    "空对象: `{}`\n",
    "  - 是所有对象对象的父类型(最抽象)\n",
    "  - 隐式地拥有Object的原型方法\n",
    "\n",
    "类型成员 (Type Member):\n",
    "  - 属性签名(Property Signature) - 或访问器\n",
    "\n",
    "  - 方法签名(Method Signature) 方法的类型\n",
    "    - ```ts\n",
    "      // toString 的方法签名\n",
    "      { toString(): string }\n",
    "      ```\n",
    "<!-- /* 倒错, 无法再定义 __call__ */ -->\n",
    "  调用签名(Call Signature)对象中的无名函数属性\n",
    "\n",
    "<!-- /* 倒错, 无法再定义 __call__ */ -->\n",
    "  构造签名(Construct Signature) 对象中带new的的无名函数属性\n",
    "\n",
    "\n",
    "  索引签名（Index Signature）- 可放在所有的 对象定义中, Record 类型\n",
    "\n",
    "字面量:\n",
    "  - numeric-literal [数字字面量]:\n",
    "    1n,2,3_1,\n",
    "  - string-literal [字符串字面量]:\n",
    "    \"\", \\`\\`, 'abc', \\`${number}\\`,\n",
    "  - type-primitive [基元类型]:\n",
    "    - `string|number|boolean|bigint|symbol|any|void|never|unknown` 9 种\n",
    "  - type-builtin-literals [内建字面量]:\n",
    "    - `this|true|false|undefined|null|object` 6 种\n",
    "\n",
    "\n",
    "混合类型(Hybrid Types):\n",
    "  包含 方法签名 和 对象属性 的类型\n",
    "> 仅包含一个类型成员并且是调用签名类型成员的对象类型字面量 (原始对象) 等同于 函数类型字面量, 可去除大括号\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 接口\n",
    "\n",
    "接口类型的声明是一种引用(一定为对象类型), class 可以实现绝大部分接口(对比: class不能实现 alias 定义的非对象类型)\n",
    "\n",
    "接口继承\n",
    "  - 继承的成员类型 只能逆变或不变\n",
    "  - 接口继承类(极其少)\n",
    "     - 接口同样会继承到类的private和protected成员，但不继承实现\n",
    "        - 这会阻止接口重载类里的限制访问字段\n",
    "        - 这之后的这个接口可能无法实现类; 因为无法拥有 原基类的私有成员的实现, 且无法拥有同名私有属性\n",
    "\n",
    "类实现接口\n",
    "  - 实现的成员类型 只能协变或不变\n",
    "  - 实现的成员类型 必须是接口声明的成员类型的子集(逆变)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "索引签名\n",
    "  - 拓宽对象类型的类型定义\n",
    "\n",
    "\n",
    "同名合并\n",
    "  - 外部用: interface, 内部用: type\n",
    "\n",
    "类型计算时: 静态推导, 同一个类型在所有处相同(结果)\n",
    "\n",
    "运行时检查对象是否是某接口的实例\n",
    "  - 应该使用zod之类的参数校验库\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 类\n",
    "\n",
    "类声明\n",
    "  - 普通类\n",
    "  - 抽象类\n",
    "\n",
    "类继承\n",
    "  - 继承(抽象/普通)类\n",
    "  - 实现(接口/类)\n",
    "\n",
    "成员访问权限标识符\n",
    "  - public\n",
    "  - private\n",
    "  - protected\n",
    "  - es2022 私有属性 #field\n",
    "\n",
    "属性访问权限标识符\n",
    "  - readonly\n",
    "  - static\n",
    "\n",
    "索引签名\n",
    "方法重载(访问器无法重载)\n",
    "  - 只定义 get 访问器。则可以视为只读属性\n",
    "  - 只定义 set 访问器，这个属性是只写的？并非，读的时候不会出现报错，可以读到 undefined\n",
    "\n",
    "this (值/类型)\n",
    "  - 默认为当前类的类型\n",
    "  - ThisType，给函数表达式使用，指定 隐式this 的类型\n",
    "\n",
    "构造函数\n",
    "  - 定义属性初始化\n",
    "\n",
    "类的标识符(值)的类型为 类的构造器签名\n",
    "类的prototype的类型为 标识符引用的类型\n",
    "\n",
    "类静态块 和 静态属性享受同一顺序生命周期\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 泛型(对于类型构造器)\n",
    "\n",
    "两个类型的交集\n",
    "\n",
    "可以使用泛型的地方\n",
    "  - 函数\n",
    "  - 类\n",
    "  - 接口\n",
    "  - alias\n",
    "\n",
    "类型默认值\n",
    "extends约束\n",
    "\n",
    "类型比较(extends)的方向: 具体到抽象; 正向为协变, 逆向为逆变\n",
    "  - never为下界, unknown为上界, any为不定(不检查)\n",
    "  - 类型参数(泛型)形参 默认为unknown\n",
    "\n",
    "## 协变（Covariance）：\n",
    "\n",
    "对于两个类型A和B，如果A是B的子类型，并且`C<A>`是`C<B>`的子类型，string[]是 unknown[]的子类型。\n",
    "\n",
    "## 逆变（Contravariance）：\n",
    "\n",
    "对于两个类型A和B，如果A是B的子类型，并且`C<B>`是`C<A>`的子类型，那么类型构造器C是逆变的。这与协变的方向相反。\n",
    "\n",
    "## 不变（Invariance）：\n",
    "\n",
    "如果对于类型A和B（A是B的子类型），`C<A>`和`C<B>`没有子类型关系，那么类型构造器C是不变的。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. 高级类型\n",
    "\n",
    "联合类型, \n",
    "  - 单位元是 never 即 1 = 1 | never    \n",
    "  - 计算结果往unknown逼近\n",
    "交叉类型, \n",
    "  - 单位元是 unknown 即 1 = 1 & unknown\n",
    "  - 计算是往never逼近\n",
    "\n",
    "工具类型\n",
    "  - Partial\n",
    "  - Required\n",
    "  - Readonly\n",
    "  - Record\n",
    "  - Pick\n",
    "  - Omit\n",
    "  - Exclude\n",
    "  - Extract\n",
    "  - NonNullable\n",
    "  - Parameters\n",
    "  - ReturnType\n",
    "  - InstanceType\n",
    "  - ConstructorParameters\n",
    "  - ThisParameterType\n",
    "  - OmitThisParameter\n",
    "  - ThisType\n",
    "  - Uppercase\n",
    "  - Lowercase\n",
    "\n",
    "### 8.1 高级用法\n",
    "\n",
    "类型保护(类型守卫)或类型区分 (值空间)\n",
    "  - if \n",
    "  - switch\n",
    "  - instanceof\n",
    "  - in\n",
    "  - typeof\n",
    "  - !\n",
    "\n",
    "枚举成员类型\n",
    "  - 反向映射\n",
    "\n",
    "接口: 纯惰性计算\n",
    "别名: 单层内迫切计算\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Iterator 和 Generator\n",
    "\n",
    "Iterator\n",
    "  - Symbol.iterator\n",
    "  - DOM_API Iterator\n",
    "  - ```ts\n",
    "    Iterator<T, TReturn = any, TNext = undefined>\n",
    "    ```\n",
    "Generator\n",
    "并行遍历多个可迭代对象\n",
    "\n",
    "[Generator例子](lib\\types\\base.ts#L11)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. 装饰器\n",
    "\n",
    "代理对象 Proxy\n",
    "属性描述 PropertyDescriptor\n",
    "\n",
    "\n",
    "旧装饰器:\n",
    "  - 类装饰器\n",
    "  - 属性装饰器\n",
    "  - 方法装饰器\n",
    "  - 参数装饰器\n",
    "\n",
    "新装饰器\n",
    "  - 类装饰器\n",
    "  - 属性装饰器\n",
    "  - 方法装饰器\n",
    "  - get装饰器\n",
    "  - set装饰器\n",
    "  - 访问符装饰器\n",
    "\n",
    "```ts\n",
    "enum DecoKind {\n",
    "  class\n",
    "  field\n",
    "  method\n",
    "  getter\n",
    "  setter\n",
    "  accessor\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "除了 类装饰器 和 方法装饰器, 其他的装饰器都依赖 reflect-metadata\n",
    "\n",
    ">更多 信息 Lit: [avoiding-issues-with-class-fields](https://lit.dev/docs/components/properties/#avoiding-issues-with-class-fields)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. 命名空间\n",
    "\n",
    "类似于一个模块环境\n",
    "\n",
    "12. es导入语句 -\\> Part2\n",
    "\n",
    "13. es导出语句 -\\> Part2\n",
    "\n",
    "import 不会对同一模块触发多次加载\n",
    "\n",
    "  加载顺序为\n",
    "  1. 先运行最深的模块，\n",
    "  2. 运行中触发: 先触发 模块effect，注册Task和iife, 运行Microtask, 结束本模块\n",
    "  3. 如果 有 top-level await 则像同步代码那样等待至完成\n",
    "\n",
    "  完成全部加载:\n",
    "  1. 在根模块完成后，\n",
    "  2. 执行注册的 iife,\n",
    "  3. 执行注册的 setImmediate, // node\n",
    "  4. 执行注册的 setTimeout\n",
    "\n",
    "[例子](src\\utils\\import-l2\\SPEC.md)\n",
    "\n",
    "14. 声明文件\n",
    "\n",
    "dts文件可以为js文件提供类型声明(开启选项 allowJs)\n",
    "dts文件可以为提供任何文件的导入提供类型声明(开启选项 allowArbitraryExtensions)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 类型系统\n",
    "\n",
    "结构化类型(Structure Type)\n",
    "  - [结构化类型](lib\\ipy-realm\\focus\\NominalType.ts#L8)\n",
    "名义化类型(Nominal Type)\n",
    "  - [名义化类型](lib\\ipy-realm\\focus\\NominalType.ts#L12)\n",
    "\n",
    "类型推断(Type Inference)\n",
    "  - 初始化\n",
    "\n",
    "  - [上下文类型](lib\\ipy-realm\\focus\\context.ts#L12)\n",
    "\n",
    "类型兼容性\n",
    "  - 泛型\n",
    "\n",
    "类型断言\n",
    "  - 值的类型断言\n",
    "\n",
    "双重断言\n",
    "  - [as xx as yy](lib\\swc-ts\\base.ts#L12)\n",
    "非空断言\n",
    "  - `func!()`\n",
    "  - `obj!.a`\n",
    "  - `let v!`\n",
    "\n",
    "断言函数(返回值类型)\n",
    "  - [类型谓词](lib\\ts\\annotate-type.ts#L12)\n",
    "  \n",
    "  - [断言签名](lib\\ts\\annotate-type.ts#L20)\n",
    "\n",
    "类型收窄(分支)\n",
    "  - [穷尽检查](lib\\ts\\enum.ts#L18)\n",
    "\n",
    "声明空间\n",
    "  - [值空间和类型空间](lib\\ts\\two-platform.ts)\n",
    "条件类型\n",
    "\n",
    "模板字符串字面量类型\n",
    "  - [`${string}`](lib\\ts\\type-computed.ts#L2)\n",
    "映射类型\n",
    "  - [带修饰符修改的对象类型](lib\\ts\\stable-type.ts#L33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Reflect Metadata\n",
    "#### 3. 函数类型\n",
    "\n",
    "函数参数类型\n",
    "  - 可以通过 `Parameter` 类型工具 获取函数的参数类型\n",
    "\n",
    "函数返回类型\n",
    "  - 可以通过 `ReturnType` 类型工具 获取函数的返回值类型\n",
    "  - 类型谓词 \n",
    "    - 实际为boolean\n",
    "  - 断言签名 \n",
    "    - 实际为void\n",
    "\n",
    "函数重载\n",
    "\n",
    "#### 4. 函数式\n",
    "  - [HKT](lib\\ts\\hkt-pr\\base.ts)\n",
    "#### 5. TypeScript 世界观\n",
    "  - [类型体操](lib)\n",
    "#### 6. 接口类型判断和保护\n",
    "#### 7. 类型体操\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 8. 模块\n",
    "\n",
    "### 8.1 导出模块\n",
    "\n",
    "非模块: 在未开启 isolatedModule 时, 无导入导出语句的文件被视为 脚本共享全局命名空间\n",
    "\n",
    "可导出的内容\n",
    "\t- 变量值\n",
    "\t- 函数\n",
    "\t- 类\n",
    "\t- namespace(主要使用在cjs)\n",
    "\t- alias(类型)\n",
    "  - 接口(类型)\n",
    "\n",
    "命名导出\n",
    "\n",
    "声明导出\n",
    "  - `export {} from \"xxx\"`\n",
    "\n",
    "导出别名\n",
    "  - `export { foo as default }`\n",
    "\n",
    "默认导出\n",
    "\t- 只是输出一个叫做 default 的变量 (commonjs)\n",
    "\t- 符号绑定\n",
    "\n",
    "重新导出\n",
    "  - index barrier file\n",
    "\n",
    "> 会导致解析速度变慢\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.2 导入\n",
    "\n",
    "静态导入\n",
    "  - 默认导入\n",
    "  - [展开导入](src\\components\\AppRoot.ts#L4)\n",
    "  - [命名空间导入](lib\\ts\\require-l2\\require-l2.ts#L6)\n",
    "  - 类型导入\n",
    "    - 默认导入的scope类型标记(markers)\n",
    "    - 单个导入值的类型标记\n",
    "  - [内联导入](src\\env.d.ts#L2)\n",
    "  - 空导入\n",
    "    - 空的 类型scope导入 语句会被擦除, 空的 值导入 语句会被保留\n",
    "\n",
    "\n",
    "动态导入\n",
    "  - import 调用\n",
    "\n",
    "模块解析策略(resolver)\n",
    "  - Node10\n",
    "  - Bundler\n",
    "\n",
    "导入断言(esnext)\n",
    "\n",
    "```ts\n",
    "import { name } from './package.json' with { type: 'json' };\n",
    "\n",
    "// ts 5.3\n",
    "import type { TypeFromImport } from \"pkg\" with {\n",
    "    \"resolution-mode\": \"import\"\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Mixin\n",
    "\n",
    "把两个类结合\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Deno",
   "language": "typescript",
   "name": "deno"
  },
  "language_info": {
   "name": "typescript"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
